FEXPModelBuilder.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Manages assembly of FE model.
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPMODELBUILDER_H_
#define _CFEXPMODELBUILDER_H_
#include "FEXPCommon.h"
#include "FEXPElement.h"
#include "FEXPSerializeData.h"


class ICFEXPModelBuilderBase
{
public:
  virtual ~ICFEXPModelBuilderBase() { }

  // model container
  virtual Ptr<ICFEXPDataModelContIntf> GetModelContainer() = 0;
  // add model data
  virtual bool BuildModel        (const std::string & key, Ptr<std::vector<std::string>> fcontent, Ptr<ICFEXPDataContIntf> data) = 0;
  virtual bool BuildModelProgress(const std::string & key, Ptr<std::vector<std::string>> fcontent, Ptr<ICFEXPDataContIntf> data) = 0;
  // removs structure from model (for NETWORK solution)
  virtual void RemoveStructure        (const std::string & key) = 0;
  virtual bool RemoveStructureProgress(const std::string & key) = 0;
  // thread scheduling
  virtual void ScheduleThreads        (size_t opt_id) = 0;
  virtual bool ScheduleThreadsProgress(size_t opt_id) = 0;
  // serialization
  virtual Ptr<t_SerializedData> NetSerializeStructure  (const std::string & key)                                 = 0;
  virtual void                  NetDeserializeStructure(const std::string & key, Ptr<t_SerializedData> ser_data) = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// primary template
template<typename TInCont, typename TMoCont, typename Enable = void>
class CFEXPModelBuilder { };
template<typename TInCont, typename TMoCont>
class CFEXPModelBuilder
  // specialization
  <TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                             std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  : public ICFEXPModelBuilderBase
{
public:
  CFEXPModelBuilder(
    const std::string & build_proc_text, const std::string & remove_proc_text, const std::string & schdl_proc_text);
  CFEXPModelBuilder(Ptr<TMoCont> & model_cont,
    const std::string & build_proc_text, const std::string & remove_proc_text, const std::string & schdl_proc_text);
  virtual ~CFEXPModelBuilder() { }

  // override pure virtual functions -- model getter
  virtual Ptr<ICFEXPDataModelContIntf> GetModelContainer() override { return FEXPCOMMON_STACAST(TMoCont, ICFEXPDataModelContIntf, _mo_container); }
  // override pure virtual functions -- for model building
  virtual bool BuildModel        (const std::string & key, Ptr<std::vector<std::string>> fcontent, Ptr<TInCont> data) override;
  virtual bool BuildModelProgress(const std::string & key, Ptr<std::vector<std::string>> fcontent, Ptr<TInCont> data) override;
  // override pure virtual functions -- for NETWORK solution
  virtual void RemoveStructure        (const std::string & key) override;
  virtual bool RemoveStructureProgress(const std::string & key) override;
  // override pure virtual functions -- thread scheduling
  virtual void ScheduleThreads        (size_t opt_id) override;
  virtual bool ScheduleThreadsProgress(size_t opt_id) override;
  // override pure virtual functions -- network serialization
  virtual Ptr<t_SerializedData> NetSerializeStructure  (const std::string & key)                                 override;
  virtual void                  NetDeserializeStructure(const std::string & key, Ptr<t_SerializedData> ser_data) override;
protected:
  // [no protected members] -----------------------------
private:
  std::string _build_proc_text;
  std::string _remve_proc_text;
  std::string _schdl_proc_text;
  // model input data
  struct input_data
  {
    Ptr<std::vector<std::string>> _in_file_content;
    Ptr<TInCont>                  _in_data_container;
    input_data(Ptr<std::vector<std::string>> fcontent, Ptr<TInCont> container)
      : _in_file_content(fcontent), _in_data_container(container) { }
  };
  std::map<std::string, Ptr<input_data>> _in_contr_map;
  Ptr<TMoCont>                           _mo_container;
  // mapping data to each model -- network solution
  size_t                                 _model_id_generator;
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                            std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::CFEXPModelBuilder(
    const std::string & build_proc_text, const std::string & remove_proc_text, const std::string & schdl_proc_text)
  : ICFEXPModelBuilderBase(),
  _build_proc_text(build_proc_text), _remve_proc_text(remove_proc_text), _schdl_proc_text(schdl_proc_text),
  _mo_container(CFEXPDataManager<TMoCont>::SafeAllocInstance()), _model_id_generator(FEXPCOMMON_DEFAULT_VALUE) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                            std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::CFEXPModelBuilder(Ptr<TMoCont> & model_cont,
    const std::string & build_proc_text, const std::string & remove_proc_text, const std::string & schdl_proc_text)
  : ICFEXPModelBuilderBase(),
  _build_proc_text(build_proc_text), _remve_proc_text(remove_proc_text), _schdl_proc_text(schdl_proc_text), _mo_container(model_cont),
  _model_id_generator(FEXPCOMMON_DEFAULT_VALUE) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
bool CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                                 std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::BuildModel(const std::string & key, Ptr<std::vector<std::string>> fcontent, Ptr<TInCont> data)
//--------------------------------------------------------------------------------------
{
  if (_in_contr_map.count(key))
    return false;
  _in_contr_map.insert(MAP_PAIR(key, CFEXPDataManager<input_data>::SafeAllocInstance(fcontent, data)));
  data->SetData(FEXPCOMMON_STACAST(TMoCont, ICFEXPDataModelContIntf, _mo_container), key);
  return true;
}

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
bool CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                                 std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::BuildModelProgress(const std::string & key, Ptr<std::vector<std::string>> fcontent, Ptr<TInCont> data)
//--------------------------------------------------------------------------------------
{
  return CFEXPAsyncRunner::RunProcedureTask([this, &key, &fcontent, &data] { BuildModel(key, fcontent, data); }, true, _build_proc_text, true);
}

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
void CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                                 std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::RemoveStructure(const std::string & key)
//--------------------------------------------------------------------------------------
{
  if (!_in_contr_map.count(key))
    return;
  _in_contr_map[key]->_in_data_container->RmvData(FEXPCOMMON_STACAST(TMoCont, ICFEXPDataModelContIntf, _mo_container));
  _in_contr_map.erase(_in_contr_map.find(key));
}

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
bool CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                                 std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::RemoveStructureProgress(const std::string & key)
//--------------------------------------------------------------------------------------
{
  return CFEXPAsyncRunner::RunProcedureTask([this, &key] { RemoveStructure(key); }, true, _remve_proc_text, true);
}

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
void CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                                 std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::ScheduleThreads(size_t opt_id)
//--------------------------------------------------------------------------------------
{
  _mo_container->ScheduleThreads(opt_id);
}

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
bool CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                                 std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::ScheduleThreadsProgress(size_t opt_id)
//--------------------------------------------------------------------------------------
{
  return CFEXPAsyncRunner::RunProcedureTask([this,&opt_id] { ScheduleThreads(opt_id); }, true, _schdl_proc_text, true);
}

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
Ptr<t_SerializedData> CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf, TInCont>::value &&
                                                                   std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::NetSerializeStructure(const std::string & key)
//--------------------------------------------------------------------------------------
{
  if (!_in_contr_map.count(key))
    return Ptr<t_SerializedData>();
  return _in_contr_map[key]->_in_data_container->SerData(FEXPCOMMON_STACAST(TMoCont, ICFEXPDataModelContIntf, _mo_container));
}

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
void CFEXPModelBuilder<TInCont, TMoCont, typename std::enable_if<std::is_base_of<ICFEXPDataContIntf     , TInCont>::value &&
                                                                 std::is_base_of<ICFEXPDataModelContIntf, TMoCont>::value>::type>
  ::NetDeserializeStructure(const std::string & key, Ptr<t_SerializedData> ser_data)
//--------------------------------------------------------------------------------------
{
  if (!_in_contr_map.count(key))
    return;
  _in_contr_map[key]->_in_data_container->DesData(FEXPCOMMON_STACAST(TMoCont, ICFEXPDataModelContIntf, _mo_container), ser_data);
}


template<typename TInCont, typename TMoCont>
class CFEXPServerModelBuilder
  : public CFEXPModelBuilder<TInCont, TMoCont>
{
public:
  CFEXPServerModelBuilder();
  CFEXPServerModelBuilder(Ptr<TMoCont> & model_cont);
  virtual ~CFEXPServerModelBuilder() { }

  // not used interface methods
  // override pure virtual functions -- for NETWORK solution
  virtual void RemoveStructure        (const std::string & key) override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
  virtual bool RemoveStructureProgress(const std::string & key) override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
  // override pure virtual functions -- thread scheduling
  virtual void ScheduleThreads        (size_t opt_id) override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
  virtual bool ScheduleThreadsProgress(size_t opt_id) override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
CFEXPServerModelBuilder<TInCont, TMoCont>
  ::CFEXPServerModelBuilder()
  : CFEXPModelBuilder<TInCont, TMoCont>("Building server data", FEXPCOMMON_EMPTY_STRING, FEXPCOMMON_EMPTY_STRING) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TInCont, typename TMoCont>
CFEXPServerModelBuilder<TInCont, TMoCont>
  ::CFEXPServerModelBuilder(Ptr<TMoCont> & fe_cont)
  : CFEXPModelBuilder<TInCont, TMoCont>(fe_cont, "Building server data", FEXPCOMMON_EMPTY_STRING, FEXPCOMMON_EMPTY_STRING) { }
//--------------------------------------------------------------------------------------

#endif // !_CFEXPMODELBUILDER_H_